{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">官方教程：https://python-gino.org/docs/zh/master/tutorials/tutorial.html\n",
    "\n",
    "\n",
    "# 介绍 [¶](#introduction \"永久链接至标题\")\n",
    "\n",
    "简单来说，GINO 可以在您的异步应用中帮助您完成 SQL 语句的生成及执行，您只需要通过友好的对象化 API 来操作您的数据即可，无需亲自编写 SQL 与数据库交互。\n",
    "\n",
    "因为异步编程并不会使您的程序变快——如果说不拖累的话——而且还会增加复杂度和风险，所以也许您并不需要 GINO 或者说是异步数据库连接。跳坑之前请先阅读[为什么要用异步 ORM？](https://python-gino.org/docs/zh/master/explanation/why.html)。\n",
    "\n",
    "\n",
    "这是一篇写给刚入坑同学的指南，将介绍 GINO 的基本部分。阅读之前，请先了解以下知识点：\n",
    "\n",
    "*   关系型数据库，尤其是 [PostgreSQL](https://www.postgresql.org/)\n",
    "    \n",
    "*   [Python 异步编程](https://realpython.com/async-io-python/)\n",
    "    \n",
    "\n",
    "您不需要对 [SQLAlchemy](https://www.sqlalchemy.org/) 有所了解。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 安装\n",
    "\n",
    ">pip install gino\n",
    "\n",
    "# 使用\n",
    "\n",
    "## 声明模型 [¶](#declare-models \"永久链接至标题\")\n",
    "\n",
    "开始之前，我们需要先创建一个 [`Gino`](https://python-gino.org/docs/zh/master/reference/api/gino.api.html#gino.api.Gino \"gino.api.Gino\") 的全局实例，通常叫做 `db`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gino import Gino\n",
    "\n",
    "db = Gino()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`db` 可以被当做是数据库的一个代表，后续大部分的数据库交互都将通过它来完成。\n",
    "\n",
    "“Model” 是 GINO 中的一个基本概念，它表示继承自 [`db.Model`](https://python-gino.org/docs/zh/master/reference/api/gino.api.html#gino.api.Gino.Model \"gino.api.Gino.Model\") 的用户定义类。**每个 [`Model`](https://python-gino.org/docs/zh/master/reference/api/gino.declarative.html#gino.declarative.Model \"gino.declarative.Model\") 的子类代表了数据库中的一张表，**而这些类的对象则代表了对应表中的一行数据。如果您曾经使用过其它 ORM 产品，对这种映射关系应该不感到陌生。现在我们尝试定义一个 model："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class User(db.Model):\n",
    "    __tablename__ = 'users'\n",
    "\n",
    "    id = db.Column(db.Integer(), primary_key=True)\n",
    "    nickname = db.Column(db.Unicode(), default='noname')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的 `User` 类其实就是在定义一张叫做 `users` 的数据库表，包含了 `id` 和 `nickname` 两个字段。请注意，**`__tablename__` 是一个必要的固定属性**。GINO 建议使用**单数名词来为 model 命名**，同时使用**复数名词去命名表**。每个 [`db.Column`](https://docs.sqlalchemy.org/en/13/core/metadata.html#sqlalchemy.schema.Column \"(在 SQLAlchemy v1.3)\") 属性都定义了一个数据库字段，其中第一个参数是字段类型，其余参数则用来定义字段其他属性或约束。您可以参考 [SQLAlchemy](http://docs.sqlalchemy.org/en/latest/core/type_basics.html) 的文档来了解不同 `db` 类型到数据库类型的对应关系。\n",
    "\n",
    ">注解:  \n",
    "[SQLAlchemy](https://www.sqlalchemy.org/) 是 Python 中一个强大的非异步 ORM 库，而 GINO 就是基于其构建的。通过不同的 SQL 方言实现，SQLAlchemy 支持包括 PostgreSQL 和 MySQL 在内的许多流行的 RDBMS，以至于有时相同的 Python 代码可以不经修改地运行在不同的数据库上。GINO 自然也承袭了这一特性，**但目前暂仅支持 PostgreSQL**（通过 [asyncpg](https://github.com/MagicStack/asyncpg)）。\n",
    "\n",
    "如果需要定义涵盖多个列的数据库约束或索引，您仍然可以通过 model 类属性的方式来定义，属性名称虽未被用到，但不能重复。例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Booking(db.Model):\n",
    "    __tablename__ = 'bookings'\n",
    "\n",
    "    day = db.Column(db.Date)\n",
    "    booker = db.Column(db.String)\n",
    "    room = db.Column(db.String)\n",
    "\n",
    "    _pk = db.PrimaryKeyConstraint('day', 'booker', name='bookings_pkey')\n",
    "    _idx1 = db.Index('bookings_idx_day_room', 'day', 'room', unique=True)\n",
    "    _idx2 = db.Index('bookings_idx_booker_room', 'booker', 'room')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "另外如果有倾向性，您也可以在 model 类之外定义约束和索引，请参考 [SQLAlchemy 文档](http://docs.sqlalchemy.org/en/latest/core/constraints.html)来了解更多细节。\n",
    "\n",
    "由于一些限制，目前不允许在父类中直接使用类属性的方式来单独定义数据库约束和索引，`__table_args__` 也是一样的。GINO 提供了 [`declared_attr()`](https://python-gino.org/docs/zh/master/reference/api/gino.declarative.html#gino.declarative.declared_attr \"gino.declarative.declared_attr\") 来实现比如 mixin 类这样的功能，更多信息请参阅其 API 文档。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立连接 [¶](#get-connected \"永久链接至标题\")\n",
    "\n",
    "前面的声明只是定义了映射关系，并非实际在数据库中创建了这些表结构。为了使用 GINO 来创建表，我们需要先与数据库建立连接。这里我们先为本指南创建一个 PostgreSQL 的数据库实例：\n",
    "\n",
    "然后，告诉我们的 `db` 对象去连接这个数据库："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import asyncio\n",
    "\n",
    "async def main():\n",
    "    await db.set_bind('postgresql://postgre:xxxx@47.102.127.xxx:5432/gino')\n",
    "\n",
    "asyncio.get_event_loop().run_until_complete(main())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果执行成功了，那就意味着您连上了新创建的数据库。此处的 `postgresql` 代表了要用的数据库方言（默认的驱动是 `asyncpg`，您也可以显式地指定使用它：`postgresql+asyncpg://` 或者就只写 `asyncpg://`），`localhost` 是数据库服务器所在的地址，`gino` 是数据库实例的名字。[这里](https://docs.sqlalchemy.org/en/latest/core/engines.html)可以读到更多关于如何构造一个数据库 URL 的信息。\n",
    "\n",
    ">注解:  \n",
    "在底层，[`set_bind()`](https://python-gino.org/docs/zh/master/reference/api/gino.api.html#gino.api.Gino.set_bind \"gino.api.Gino.set_bind\") 调用了 [`create_engine()`](https://python-gino.org/docs/zh/master/reference/api/gino.html#gino.create_engine \"gino.create_engine\") 来创建 engine，并将其绑定到 `db` 对象上。GINO engine 与 SQLAlchemy engine 类似，但 GINO engine 是异步的，而后者是阻塞式的。关于如何使用 engine，请参考 GINO 的 API 文档。\n",
    "\n",
    "建立连接之后，我们就可以用 GINO 在数据库中创建我们的表了（在同一个 `main()` 函数里）：\n",
    "\n",
    "```py\n",
    "await db.gino.create_all()\n",
    "```\n",
    ">警告  \n",
    "这里是 `db.gino.create_all`，而不是 `db.create_all`，因为 db 继承自 SQLAlchemy 的 MetaData，而 `db.create_all` 是 SQLAlchemy 的阻塞式方法，无法适用于绑定的 GINO engine。\n",
    "\n",
    ">实践中 `create_all()` 通常并不是一个理想的解决方案。为了管理数据库表结构，我们通常推荐使用诸如 Alembic 这样的工具，请参阅如何 使用 [Alembic](https://python-gino.org/docs/zh/master/how-to/alembic.html)。\n",
    "如果您想显式地断开与数据库的连接，您可以这么做：\n",
    "\n",
    "```py\n",
    "await db.pop_bind().close()\n",
    "```\n",
    "\n",
    "继续之前，让我们重新看一下前面所有的代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import asyncio\n",
    "from gino import Gino\n",
    "\n",
    "db = Gino()\n",
    "\n",
    "\n",
    "class User(db.Model):\n",
    "    __tablename__ = 'users'\n",
    "\n",
    "    id = db.Column(db.Integer(), primary_key=True)\n",
    "    nickname = db.Column(db.Unicode(), default='noname')\n",
    "\n",
    "\n",
    "async def main():\n",
    "    await db.set_bind('postgresql://localhost/gino')\n",
    "    await db.gino.create_all()\n",
    "\n",
    "    # further code goes here\n",
    "\n",
    "    await db.pop_bind().close()\n",
    "\n",
    "\n",
    "asyncio.get_event_loop().run_until_complete(main())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 增删改查 [¶](#crud-operations \"永久链接至标题\")\n",
    "\n",
    "为了操作数据库中的数据，GINO 提供了基本的基于对象的增删改查功能。\n",
    "\n",
    "### 增 [¶](#create \"永久链接至标题\")\n",
    "\n",
    "让我们从创建一个 `User` 对象开始：\n",
    "\n",
    "```py\n",
    "user = await User.create(nickname='fantix')\n",
    "# This will cause GINO to execute this SQL with parameter 'fantix':\n",
    "# INSERT INTO users (nickname) VALUES ($1) RETURNING users.id, users.nickname\n",
    "```\n",
    "\n",
    "正如之前所说，`user` 对象代表了数据库中新插入的这一行数据。您可以通过 `user` 对象上的之前定义的列属性来访问每一列的值：\n",
    "\n",
    "```py\n",
    "print(f'ID:       {user.id}')           # 1\n",
    "print(f'Nickname: {user.nickname}')     # fantix\n",
    "```\n",
    "\n",
    "另外，您也可以先在内存中创建一个 `user` 对象，然后再将其插入到数据库中：\n",
    "\n",
    "```py\n",
    "user = User(nickname='fantix')\n",
    "user.nickname += ' (founder)'\n",
    "await user.create()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 查 [¶](#retrieve \"永久链接至标题\")\n",
    "\n",
    "想要通过主键来获取一个 model 对象，您可以使用 model 的类方法 [`get()`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.CRUDModel.get \"gino.crud.CRUDModel.get\")。比如，重新获取刚才插入的同一行数据：\n",
    "\n",
    "```py\n",
    "user = await User.get(1)\n",
    "# SQL (parameter: 1):\n",
    "# SELECT users.id, users.nickname FROM users WHERE users.id = $1\n",
    "```\n",
    "\n",
    "常规的 SQL 查询则是通过类属性 [`query`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.CRUDModel.query \"gino.crud.CRUDModel.query\") 来完成。比如，获取数据库中所有的 `User` 对象的列表：\n",
    "\n",
    "```py\n",
    "all_users = await db.all(User.query)\n",
    "# SQL:\n",
    "# SELECT users.id, users.nickname FROM users\n",
    "```\n",
    "\n",
    "或者，您也可以使用 [`query`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.CRUDModel.query \"gino.crud.CRUDModel.query\") 的 `gino` 扩展。比如，下面的代码可以实现一样的效果：\n",
    "\n",
    "```py\n",
    "all_users = await User.query.gino.all()\n",
    "# SQL:\n",
    "# SELECT users.id, users.nickname FROM users\n",
    "```\n",
    "\n",
    "注解\n",
    "\n",
    "实际上，`User.query` 是一个普通的 SQLAlchemy 查询对象，SQLAlchemy 的阻塞式执行方法依然存在其上，因此 GINO 向所有 SQLAlchemy 的 “Executable” 对象注入了一个 `gino` 扩展，以便在不影响 SQLAlchemy 原有 API 的基础上，让直接异步地执行这些查询对象更容易，而不用每次都通过 engine 或 `db` 对象来执行。\n",
    "\n",
    "现在让我们尝试增加一些过滤器。比如，查找出所有 ID 小于 10 的用户：\n",
    "\n",
    "```py\n",
    "founding_users = await User.query.where(User.id < 10).gino.all()\n",
    "# SQL (parameter: 10):\n",
    "# SELECT users.id, users.nickname FROM users WHERE users.id < $1\n",
    "```\n",
    "\n",
    "因为查询对象就是出自于 SQLAlchemy core，所以请参阅[如何编写查询](https://docs.sqlalchemy.org/en/latest/core/expression_api.html)。\n",
    "\n",
    ">警告:  \n",
    "当您拿到一个 model 对象时，这个对象就已经彻底与数据库分离了，完全成为内存中的一个普通对象。这就意味着，即使数据库中对应的行发生了变化，对象的值仍然不会受到丝毫影响。类似地，如果您修改了该对象的值，数据库也不会受到任何影响。\n",
    "\n",
    ">并且，GINO 也不会追踪 model 对象，因此重复查询同一行数据将会得到两个独立的、拥有相同值的对象，修改其中一个的值不会幽灵般地影响到另一个的值。\n",
    "\n",
    ">不同于传统 ORM 的 model 对象通常是有状态的，GINO 的 model 对象则更像是用对象封装的 SQL 查询结果，这是 GINO 为了适应异步编程而特意设计的简易性，也是 “GINO 不是 ORM” 名字的来源。\n",
    "\n",
    "有时我们仅需要获取一个对象，比如验证登录时，使用用户名来查找一个用户。这时，可以使用这种便捷的写法：\n",
    "\n",
    "```py\n",
    "user = await User.query.where(User.nickname == 'fantix').gino.first()\n",
    "# SQL (parameter: 'fantix'):\n",
    "# SELECT users.id, users.nickname FROM users WHERE users.nickname = $1\n",
    "```\n",
    "\n",
    "如果数据库中没有叫 “fantix” 的用户，则 `user` 会被置为 `None`。\n",
    "\n",
    "又有时，我们会需要获取一个单独的值，比如 ID 为 1 的用户的名字。此时可以使用 model 的类方法 [`select()`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.CRUDModel.select \"gino.crud.CRUDModel.select\")：\n",
    "\n",
    "```py\n",
    "name = await User.select('nickname').where(User.id == 1).gino.scalar()\n",
    "# SQL (parameter: 1):\n",
    "# SELECT users.nickname FROM users WHERE users.id = $1\n",
    "print(name)  # fantix\n",
    "```\n",
    "\n",
    "又比如，查询用户数量：\n",
    "\n",
    "```py\n",
    "population = await db.func.count(User.id).gino.scalar()\n",
    "# SQL:\n",
    "# SELECT count(users.id) AS count_1 FROM users\n",
    "print(population)  # 17 for example\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 改 [¶](#update \"永久链接至标题\")\n",
    "\n",
    "接下来，让我们尝试对数据做一些修改，下面的例子会穿插一些前面用过的查询操作。\n",
    "\n",
    "```py\n",
    "# create a new user\n",
    "user = await User.create(nickname='fantix')\n",
    "\n",
    "# get its name\n",
    "name = await User.select('nickname').where(\n",
    "    User.id == user.id).gino.scalar()\n",
    "assert name == user.nickname  # they are both 'fantix' before the update\n",
    "\n",
    "# modification here\n",
    "await user.update(nickname='daisy').apply()\n",
    "# SQL (parameters: 'daisy', 1):\n",
    "# UPDATE users SET nickname=$1 WHERE users.id = $2 RETURNING users.nickname\n",
    "print(user.nickname)  # daisy\n",
    "\n",
    "# get its name again\n",
    "name = await User.select('nickname').where(\n",
    "    User.id == user.id).gino.scalar()\n",
    "print(name)  # daisy\n",
    "assert name == user.nickname  # they are both 'daisy' after the update\n",
    "```\n",
    "\n",
    "这里的 [`update()`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.CRUDModel.update \"gino.crud.CRUDModel.update\") 是我们碰到的第一个 model 实例上的 GINO 方法，它接受多个自定义命名参数，参数名对应着 model 的字段名，而参数值则为期望修改成的新的值。连着写的 [`apply()`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.UpdateRequest.apply \"gino.crud.UpdateRequest.apply\") 则会将这一修改同步到数据库中。\n",
    "\n",
    ">注解:  \n",
    "GINO 显式地将“修改内存中对象的值”与“修改数据库中的行”拆分成了两个方法： update() 与 apply()。update() 负责修改内存中的值，并且将改动记录在返回的 UpdateRequest 对象中；紧接着调用的 UpdateRequest 对象的 apply() 方法则会将这些记录下的改动通过 SQL 更新到数据库中。\n",
    "\n",
    ">小技巧:  \n",
    "UpdateRequest 对象还有一个方法也叫 update()，**它与 model 对象上的 update() 方法的功能是一样的**，只不过前者还会将新的改动记录与当前 UpdateRequest 已记录的改动合并在一起，并且返回同一个 UpdateRequest 对象。**这意味着，您可以连着写多个 update() 调用，最后用一个 apply() 结尾**，或者仅仅是通过 UpdateRequest 对象来完成内存对象的多次改动。\n",
    "\n",
    "Model 对象上的 [`update()`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.CRUDModel.update \"gino.crud.CRUDModel.update\") 方法只能操作该对象对应的数据库中的一行数据，而如果您想要批量更新多行数据的话，您可以使用 model 类上的 [`update()`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.CRUDModel.update \"gino.crud.CRUDModel.update\") 类方法。用法略有不同：\n",
    "\n",
    "```py\n",
    "await User.update.values(nickname='Founding Member ' + User.nickname).where(\n",
    "    User.id < 10).gino.status()\n",
    "# SQL (parameter: 'Founding Member ', 10):\n",
    "# UPDATE users SET nickname=($1 || users.nickname) WHERE users.id < $2\n",
    "\n",
    "name = await User.select('nickname').where(\n",
    "    User.id == 1).gino.scalar()\n",
    "print(name)  # Founding Member fantix\n",
    "```\n",
    "\n",
    "这里不再有 [`UpdateRequest`](https://python-gino.org/docs/zh/master/reference/api/gino.crud.html#gino.crud.UpdateRequest \"gino.crud.UpdateRequest\") 了，所有的操作又回到了普通的 SQLAlchemy 用法，更多细节可以参考 [SQLAlchemy 的文档](https://docs.sqlalchemy.org/en/latest/core/dml.html)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 删 [¶](#delete \"永久链接至标题\")\n",
    "\n",
    "最后，删除一行数据与更新一行数据有些类似，但要简单很多：\n",
    "\n",
    "```py\n",
    "user = await User.create(nickname='fantix')\n",
    "await user.delete()\n",
    "# SQL (parameter: 1):\n",
    "# DELETE FROM users WHERE users.id = $1\n",
    "print(await User.get(user.id))  # None\n",
    "```\n",
    "\n",
    ">提示:  \n",
    "还记得内存对象的事情吗？在最后一行的 [`print()`](https://docs.python.org/3/library/functions.html#print \"(在 Python v3.8)\") 中，尽管数据库中已经没有这一行数据了，但是 `user` 对象依然在内存中，它的值也都没有变化，所以这里仍然可以用 `user.id`。\n",
    "\n",
    "或者批量删除（千万不要忘记写 `where`！是不是整个表都不想要了？）：\n",
    "\n",
    "```py\n",
    "await User.delete.where(User.id > 10).gino.status()\n",
    "# SQL (parameter: 10):\n",
    "# DELETE FROM users WHERE users.id > $1\n",
    "```\n",
    "\n",
    "有了基本的 [增删改查](https://python-gino.org/docs/zh/master/how-to/crud.html)，您应该已经可以用 GINO 做出一些不可思议的东西来了。这篇上手指南到此结束，要了解更多请继续阅读文档的剩余部分。祝编程愉快！\n",
    "\n",
    "\n",
    " [![](https://i.creativecommons.org/l/by-sa/4.0/80x15.png)](http://creativecommons.org/licenses/by-sa/4.0/)   \n",
    "本作品采用[知识共享署名 - 相同方式共享 4.0 国际许可协议](http://creativecommons.org/licenses/by-sa/4.0/)进行许可。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
